package methods;
// 封装  读入编码文件的方法 FileReadA  读入编码表 sfes的方法 FileReadB
// 译码方法 decoding

import com.sun.javafx.image.BytePixelSetter;

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;

/*
* 读入编码文件的方法 FileReadA
* 将指定文件读入   并且以字符串 数组 形式返回
*
* 简化： 以逗号为分割  读取一行后 以逗号分割
*
* */
public class DecodingMethod {
    /**
     *
     * @param file  传入编码文件 对象  绝对地址
     * @return array 返回编码的字符串数组
     */
    public ArrayList<String>  FileReadA(File file ) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader(file));
        ArrayList<String> file_array = new ArrayList<>();
//
//        byte[] bytes = new byte[1024];
//        int len=0;
//        while (!((len=fis.read(bytes))==-1)){
//            String replace = new String(bytes, 0, len).replaceAll("\\s+","");
//            char_array.add(replace.toCharArray());
//        }

        char[] chars = new char[1024];
        int len;
//        判断 每次读取分隔后的最后一个 字符串C 结尾是否为 ， 如果不是 那么这下一次 读取的字符串中 有C的一部分
        boolean flag=true;
        String PREFIX="";
        while (!((len=br.read(chars))==-1)){
//            使用 ， 作为分割符 产生 字符串数组
            String str = new String(chars, 0, len);

            String[] split_string = str.split(",");
//            flag 为false 上一个字符不完整 情况
            if (!flag){
//                先将字符串拼接 然后 继续判断  此次读入的字符串 是否完整
                file_array.add(PREFIX+split_string[0]);
                //            判断 每次读入的 数据末尾是否为  ， 如果包含则 为完整字符串

                if (str.lastIndexOf(",")==str.length()-1){
                    flag=true;
//                    为完整字符 可以直接 将split_string 从1  加入 code_array中
                    file_array.addAll(Arrays.asList(split_string).subList(1, split_string.length));

                }else {
                    flag=false;
                    // 最后一个字符不是完整的字符 需要 将最后一个字符 独立保存 等待下一次 读取 整合
                    file_array.addAll(Arrays.asList(split_string).subList(1, split_string.length - 1));
//                将split_string 最后一个字符串独立保存 等待下一次输入
                    PREFIX=split_string[split_string.length-1];
                }

            }else {
//                上一次 读入的都是完整的字符串 可以直接将其 加入code_array中
//                直接判断 此次读入是否 完整
                //            判断 此次读取数据 最后一个字符是否为 ， 如果包含则 为完整字符串
                if (str.lastIndexOf(",")==str.length()-1){
                    flag=true;
//                    为完整字符 可以直接 将split_string 按次序 加入 code_array中
                    file_array.addAll(Arrays.asList(split_string));

                }else {
                    flag=false;
                    // 最后一个字符不是完整的字符 需要 将最后一个字符 独立保存 等待下一次 读取 整合
                    file_array.addAll(Arrays.asList(split_string).subList(0, split_string.length - 1));
//                将split_string 最后一个字符串独立保存 等待下一次输入
                    PREFIX=split_string[split_string.length-1];
                }

            }
//            数据全部读取完毕 FileReadA 文件读取结束

    }
        //        关闭 输入流
        br.close();
        return file_array;
    }



//    读取编码表 将所有的 码字 和对应的 原文 存储到 decode中

    /**
     *
     * @param file 编码表文件
     * @return 返回decode 存储 码字和原文的数组
     */
    public decode FileReadB(File file) throws IOException {
//        word 提出最后一个字符
//        code 字符串 去掉最后一个' 和前6 个字符
        BufferedReader br = new BufferedReader(new FileReader(file));

        ArrayList<String> code_array = new ArrayList<>();
        ArrayList<String> word_array = new ArrayList<>();


        while (br.ready()){
            String s = br.readLine();
            System.out.println("====== s = ====");
            System.out.println(s);
//             分割编码表   依据 ,
            String[] split = s.split("\\|");


            System.out.println("=====split=====");
            for (String s1 : split) {
                System.out.println(s1);
            }
            for (String s1 : split) {
                if (s1.contains("word")){  //该字符串 包含word 原文
                  word_array.add( s1.substring(s1.length()-1,s1.length())) ;
                }
                if (s1.contains("code")){  //该字符串包含 code 码字
                    code_array.add(s1.substring(6,s1.length()-1));
                }
//                将 word  和code 添加完毕
            }
        }
//        关闭 输入流
        br.close();
        System.out.println("========word_array");
        System.out.println(word_array);
        System.out.println("============code_array");
        System.out.println(code_array);
        return new decode(word_array, code_array);
    }

// 译码方法 decoding

    /**
     *
     * @param decode  存储 code_array 和word_array
     * @param file_array 编码文件 形成的字符串
     * @return 返回原文 的字符串数组
     */
    public ArrayList<String> decoding(decode decode,ArrayList<String> file_array){
        ArrayList<String> code_array = decode.getCode_array();
        ArrayList<String> word_array = decode.getWord_array();
        System.out.println("====word_array size()========");
        System.out.println(word_array.size());
        System.out.println(word_array);
        System.out.println("====code_array size()========");
        System.out.println(code_array.size());
        System.out.println(code_array);
        ArrayList<String> result_array = new ArrayList<>();
        for (String s : file_array) {
//            拿到 编码文件字符 对应的 码字下标 index
            int index = code_array.indexOf(s);
            System.out.println("=====index=======");
            System.out.println(index);
//            用index 找到 对应的word 并添加进入 result_array
            result_array.add(word_array.get(index));


        }
        return result_array;

    }
// 将翻译好的 字符串数组 输出到指定文件

    /**
     *
     * @param file 指定的输出文件地址
     * @param result_array 翻译好的原文 字符串
     * @throws IOException
     */
    public void Decoding_file_write(File file ,ArrayList<String> result_array  ) throws IOException {
        BufferedWriter bw = new BufferedWriter(new FileWriter(file));
        Iterator<String> it_res = result_array.iterator();
        while (it_res.hasNext()){
            bw.write(it_res.next());
        }
        bw.flush();
        bw.close();
// 输出结束

    }

}
